package com.essential.bases;

/*
##变量
    在Java中，变量必须先定义后使用，在定义变量的时候，可以给它一个初始值。
    int x = 1;
    上述语句定义了一个整型int类型的变量，名称为x，初始值为1。
    不写初始值，就相当于给它指定了默认值。默认值总是0。
    变量的一个重要特点是可以重新赋值。
    变量不但可以重新赋值，还可以赋值给其他变量。

##变量之间的赋值
        int n = 100; // 定义变量n，同时赋值为100
        System.out.println("n = " + n); // 打印n的值

        n = 200; // 变量n赋值为200
        System.out.println("n = " + n); // 打印n的值

        int x = n; // 变量x赋值为n（n的值为200，因此赋值后x的值也是200）
        System.out.println("x = " + x); // 打印x的值

        x = x + 100; // 变量x赋值为x+100（x的值为200，因此赋值后x的值是200+100=300）
        System.out.println("x = " + x); // 打印x的值
        System.out.println("n = " + n); // 再次打印n的值，n应该是200还是300？

    执行int n = 100;，该语句定义了变量n，同时赋值为100，因此，JVM在内存中为变量n分配一个“存储单元”，填入值100：

          n
          │
          ▼
    ┌───┬───┬───┬───┬───┬───┬───┐
    │   │100│   │   │   │   │   │
    └───┴───┴───┴───┴───┴───┴───┘
    执行n = 200;时，JVM把200写入变量n的存储单元，因此，原有的值被覆盖，现在n的值为200：

          n
          │
          ▼
    ┌───┬───┬───┬───┬───┬───┬───┐
    │   │200│   │   │   │   │   │
    └───┴───┴───┴───┴───┴───┴───┘
    执行int x = n;时，定义了一个新的变量x，同时对x赋值，因此，JVM需要新分配一个存储单元给变量x，并写入和变量n一样的值，结果是变量x的值也变为200：

          n           x
          │           │
          ▼           ▼
    ┌───┬───┬───┬───┬───┬───┬───┐
    │   │200│   │   │200│   │   │
    └───┴───┴───┴───┴───┴───┴───┘
    执行x = x + 100;时，JVM首先计算等式右边的值x + 100，结果为300（因为此刻x的值为200），然后，将结果300写入x的存储单元，因此，变量x最终的值变为300：


          n           x
          │           │
          ▼           ▼
    ┌───┬───┬───┬───┬───┬───┬───┐
    │   │200│   │   │300│   │   │
    └───┴───┴───┴───┴───┴───┴───┘
    可见，变量可以反复赋值。注意，等号=是赋值语句，不是数学意义上的相等，否则无法解释x = x + 100。

##基本数据类型
    基本数据类型是CPU可以直接进行运算的类型。Java定义了以下几种基本数据类型：
    整数类型：byte，short，int，long
    浮点数类型：float，double
    字符类型：char
    布尔类型：boolean
    计算机内存的最小存储单元是字节（byte），一个字节就是一个8位二进制数，即8个bit。它的二进制表示范围从00000000~11111111，换算成十进制是0~255，换算成十六进制是00~ff。
    内存单元从0开始编号，称为内存地址。每个内存单元可以看作一间房间，内存地址就是门牌号。
      0   1   2   3   4   5   6  ...
    ┌───┬───┬───┬───┬───┬───┬───┐
    │   │   │   │   │   │   │   │...
    └───┴───┴───┴───┴───┴───┴───┘
    一个字节是1byte，1024字节是1K，1024K是1M，1024M是1G，1024G是1T。一个拥有4T内存的计算机的字节数量就是：
    4T = 4 x 1024G
       = 4 x 1024 x 1024M
       = 4 x 1024 x 1024 x 1024K
       = 4 x 1024 x 1024 x 1024 x 1024
       = 4398046511104
    不同的数据类型占用的字节数不一样。我们看一下Java基本数据类型占用的字节数：
           ┌───┐
      byte │   │
           └───┘
           ┌───┬───┐
     short │   │   │
           └───┴───┘
           ┌───┬───┬───┬───┐
       int │   │   │   │   │
           └───┴───┴───┴───┘
           ┌───┬───┬───┬───┬───┬───┬───┬───┐
      long │   │   │   │   │   │   │   │   │
           └───┴───┴───┴───┴───┴───┴───┴───┘
           ┌───┬───┬───┬───┐
     float │   │   │   │   │
           └───┴───┴───┴───┘
           ┌───┬───┬───┬───┬───┬───┬───┬───┐
    double │   │   │   │   │   │   │   │   │
           └───┴───┴───┴───┴───┴───┴───┴───┘
           ┌───┬───┐
      char │   │   │
           └───┴───┘
    byte恰好就是一个字节，而long和double需要8个字节。

##整型
    对于整型类型，Java只定义了带符号的整型，因此，最高位的bit表示符号位（0表示正数，1表示负数）。各种整型能表示的最大范围如下：
    同一个数的不同进制的表示是完全相同的，例如15=0xf＝0b1111。

##浮点型
    浮点类型的数就是小数，因为小数用科学计数法表示的时候，小数点是可以“浮动”的，所以称为浮点数。
    对于float类型，需要加上f后缀。
    浮点数可表示的范围非常大，float类型可最大表示3.4x1038，而double类型可最大表示1.79x10308。

##布尔类型
    布尔类型boolean只有true和false两个值，布尔类型总是关系运算的计算结果：
    Java语言对布尔类型的存储并没有做规定，因为理论上存储布尔类型只需要1 bit，但是通常JVM内部会把boolean表示为4字节整数。

##字符类型
    字符类型char表示一个字符。Java的char类型除了可表示标准的ASCII外，还可以表示一个Unicode字符：
    char类型使用单引号'，且仅有一个字符，要和双引号"的字符串类型区分开。

##引用类型
    除了上述基本类型的变量，剩下的都是引用类型。例如，引用类型最常用的就是String字符串：
    String s = "hello";
    引用类型的变量类似于C语言的指针，它内部存储一个“地址”，指向某个对象在内存的位置，后续我们介绍类的概念时会详细讨论。

##常量
    定义变量的时候，如果加上final修饰符，这个变量就变成了常量：
    常量在定义时进行初始化后就不可再次赋值，再次赋值会导致编译错误。
    常量的作用是用有意义的变量名来避免魔术数字（Magic number），例如，不要在代码中到处写3.14，而是定义一个常量。如果将来需要提高计算精度，我们只需要在常量的定义处修改，例如，改成3.1416，而不必在所有地方替换3.14。
    根据习惯，常量名通常全部大写。

##var关键字
    有些时候，类型的名字太长，写起来比较麻烦。例如：
    StringBuilder sb = new StringBuilder();
    这个时候，如果想省略变量类型，可以使用var关键字：
    var sb = new StringBuilder();
    编译器会根据赋值语句自动推断出变量sb的类型是StringBuilder。对编译器来说，语句：
    var sb = new StringBuilder();
    实际上会自动变成：

    StringBuilder sb = new StringBuilder();
    因此，使用var定义变量，仅仅是少写了变量类型而已。

##变量的作用范围
    在Java中，多行语句用{ }括起来。很多控制语句，例如条件判断和循环，都以{ }作为它们自身的范围，例如：

    if (...) { // if开始
        ...
        while (...) { // while 开始
            ...
            if (...) { // if开始
                ...
            } // if结束
            ...
        } // while结束
        ...
    } // if结束
    只要正确地嵌套这些{ }，编译器就能识别出语句块的开始和结束。而在语句块中定义的变量，它有一个作用域，就是从定义处开始，到语句块结束。超出了作用域引用这些变量，编译器会报错。举个例子：

    {
        ...
        int i = 0; // 变量i从这里开始定义
        ...
        {
            ...
            int x = 1; // 变量x从这里开始定义
            ...
            {
                ...
                String s = "hello"; // 变量s从这里开始定义
                ...
            } // 变量s作用域到此结束
            ...
            // 注意，这是一个新的变量s，它和上面的变量同名，
            // 但是因为作用域不同，它们是两个不同的变量:
            String s = "hi";
            ...
        } // 变量x和s作用域到此结束
        ...
    } // 变量i作用域到此结束
    定义变量时，要遵循作用域最小化原则，尽量将变量定义在尽可能小的作用域，并且，不要重复使用变量名。

##小结
    Java提供了两种变量类型：基本类型和引用类型
    基本类型包括整型，浮点型，布尔型，字符型。
    变量可重新赋值，等号是赋值语句，不是数学意义的等号。
    常量在初始化后不可重新赋值，使用常量便于理解程序意图。
 */
public class Variable {
    public static void main(String[] args) {
       //定义并打印变量
        int x = 100; // 定义int类型变量x，并赋予初始值100
        System.out.println(x); // 打印该变量的值

        // 重新赋值变量
        int x1 = 100; // 定义int类型变量x，并赋予初始值100
        System.out.println(x1); // 打印该变量的值，观察是否为100
        x1 = 200; // 重新赋值为200
        System.out.println(x1); // 打印该变量的值，观察是否为200

        //变量之间赋值
        int n = 100; // 定义变量n，同时赋值为100
        System.out.println("n = " + n); // 打印n的值
        n = 200; // 变量n赋值为200
        System.out.println("n = " + n); // 打印n的值
        int x2 = n; // 变量x赋值为n（n的值为200，因此赋值后x的值也是200）
        System.out.println("x2 = " + x2); // 打印x的值
        x2 = x + 100; // 变量x赋值为x+100（x的值为200，因此赋值后x的值是200+100=300）
        System.out.println("x2 = " + x2); // 打印x的值
        System.out.println("n = " + n); // 再次打印n的值，n应该是200还是300？

        //整型
        int i = 2147483647;
        int i2 = -2147483648;
        int i3 = 2_000_000_000; // 加下划线更容易识别
        int i4 = 0xff0000; // 十六进制表示的16711680
        int i5 = 0b1000000000; // 二进制表示的512
        long l = 9000000000000000000L; // long型的结尾需要加L

        //浮点数
        float f1 = 3.14f;
        float f2 = 3.14e38f; // 科学计数法表示的3.14x10^38
        double d = 1.79e308;
        double d2 = -1.79e308;
        double d3 = 4.9e-324; // 科学计数法表示的4.9x10^-324

        //布尔类型
        boolean b1 = true;
        boolean b2 = false;
        boolean isGreater = 5 > 3; // 计算结果为true
        int age = 12;
        boolean isAdult = age >= 18; // 计算结果为false

        //字符类型
        char a = 'A';
        char zh = '中';
        System.out.println(a);
        System.out.println(zh);

        //引用类型
        String s = "hello";

        //常量
        final double PII = 3.14; // PI是一个常量
        double r = 5.0;
        double area = PII * r * r;
        //PII = 300; // compile error!

    }
}
